{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# User's Guide, Chapter 26: Stream Iteration and Filtering\n",
    "\n",
    "We learned enough about streams in :ref:`Chapter 6 <usersGuide_06_stream2>` to be able to get started, but you've preservered and hopefully are ready to learn more about how to get the most out of getting through a score.  So this chapter will delve deeper into the concept of iteration, that is, going through an object one step at a time, and filtering out elements so only those in classes or areas you want are found.  Let's review and describe the concept of iteration in Python (or most programming languages) for a second.\n",
    "\n",
    "Suppose you had a list like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "letterList = ['a', 'b', 'c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you could get your ABCs out of it in this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet = ''\n",
    "alphabet += letterList[0]\n",
    "alphabet += letterList[1]\n",
    "alphabet += letterList[2]\n",
    "alphabet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But it's far easier, especially for a big list, to _iterate_ over it using a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabet = ''\n",
    "for letter in letterList:\n",
    "    alphabet += letter\n",
    "\n",
    "alphabet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can _iterate_ over a list because lists are _iterable_ (or, conversely, for the tautology department, because we can _iterate_ over a list, we call it _iterable_) and there are some functions and methods that do great things on iterable objects, such as join them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''.join(letterList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or give the minimum value from a numeric list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3423"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min([10, 20, 30, -3423, 40])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or give the length of an iterable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(letterList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, there's a special type of _iterable_ object called a _generator_ which gives out objects as they are needed.  One generator that we have seen already is the `range()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 51)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeroToFifty = range(51)\n",
    "zeroToFifty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can find the first number in that range that is divisible by 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for n in zeroToFifty:\n",
    "    print(n)\n",
    "    if n != 0 and n % 5 == 0:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point we've stopped going through the `range` object and no more numbers are ever made or stored in memory -- this point doesn't matter to much for a set of numbers up to 50, but for numbers up to millions, or, as we will see, a repertory of scores of hundreds of thousands of notes, saving a few seconds here and there really adds up.\n",
    "\n",
    "Streams, as we have seen, are iterable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Note C#> 1.0\n",
      "<music21.note.Rest rest> 2.0\n",
      "<music21.note.Note D> 1.5\n",
      "<music21.note.Rest rest> 1.0\n"
     ]
    }
   ],
   "source": [
    "s = stream.Part(id='restyStream')\n",
    "s.append(note.Note('C#'))\n",
    "s.append(note.Rest(quarterLength=2.0))\n",
    "s.append(note.Note('D', quarterLength=1.5))\n",
    "s.append(note.Rest(quarterLength=1.0))\n",
    "\n",
    "for thing in s:\n",
    "    print(thing, thing.quarterLength)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you iterate over a Stream, it is actually creating a lightweight object called a `StreamIterator` to help make things easier.  We can create one directly by calling `.iter` on any stream:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.stream.iterator.StreamIterator for Part:restyStream @:0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sIter = s.iter\n",
    "sIter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This information tells us that `sIter` is an iterator going over the `Part` object with id `restyStream` and it is currently ready to give out the first object, number 0.  We can get the next thing in the Stream by calling `next()` on the Stream."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.note.Note C#>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(sIter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.note.Rest rest>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(sIter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.stream.iterator.StreamIterator for Part:restyStream @:2>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sIter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But for the most part, you'll want to use the built in way of going through an iterable, that is, with a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Note C#> 1.0\n",
      "<music21.note.Rest rest> 2.0\n",
      "<music21.note.Note D> 1.5\n",
      "<music21.note.Rest rest> 1.0\n"
     ]
    }
   ],
   "source": [
    "for el in sIter:\n",
    "    print(el, el.quarterLength)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering elements in iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So this does exactly what iterating directly on the Stream does -- but it's good to know that a `StreamIterator` is silently being generated so that you can see what else these Iterators do.  Most importantly, a `StreamIterator` can add filters to it.  Let's add a `ClassFilter` from the :ref:`moduleStreamFilters` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Rest rest> 2.0\n",
      "<music21.note.Rest rest> 1.0\n"
     ]
    }
   ],
   "source": [
    "restFilter = stream.filters.ClassFilter('Rest')\n",
    "restIterator = sIter.addFilter(restFilter)\n",
    "for el in restIterator:\n",
    "    print(el, el.quarterLength)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when we go through sIter, we are only getting those objects that match all of the filters on it.  We can also filter by offset.  Let's create a new iterator and add an :class:`~music21.stream.filters.OffsetFilter` to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Rest rest> 1.0\n",
      "<music21.note.Note D> 3.0\n"
     ]
    }
   ],
   "source": [
    "sIter2 = s.iter\n",
    "offsetFilter = stream.filters.OffsetFilter(offsetStart=0.5, offsetEnd=4.0)\n",
    "offsetIterator = sIter2.addFilter(offsetFilter)\n",
    "for el in offsetIterator:\n",
    "    print(el, el.offset)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ".. note::\n",
    "\n",
    "   prior to Music21 v.6, `sIter.addFilter()` would modify `sIter` in place and not return a new iterator.  \n",
    "   Thus in v.5.7, you would have written the last three lines of the code as:\n",
    "   \n",
    "   >>> sIter2.addFilter(offsetFilter)\n",
    "   >>> for el in sIter2:\n",
    "   ...     print(el, el.offset)\n",
    "\n",
    "   The changed behavior in v.6 will not affect most users, but it is one of the \n",
    "   biggest backward incompatible changes -- it was worth breaking code to finally \n",
    "   get this right."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple filters can be chained together to get something more powerful:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Rest rest> 1.0\n"
     ]
    }
   ],
   "source": [
    "for el in s.iter.addFilter(restFilter).addFilter(offsetFilter):\n",
    "    print(el, el.offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other filters that `music21` has in the :ref:`moduleStreamFilters` include:\n",
    "\n",
    "* :class:`~music21.stream.filters.IsFilter` which returns elements that are exactly the same as the objects passed in (useful for getting the context of an object in a stream)\n",
    "\n",
    "* :class:`~music21.stream.filters.IsNotFilter`, even more useful, for getting everything but an object or list of objects\n",
    "\n",
    "* :class:`~music21.stream.filters.IdFilter` for finding items by Id.\n",
    "\n",
    "* :class:`~music21.stream.filters.ClassNotFilter` for finding items other than a list of classes.\n",
    "\n",
    "* and :class:`~music21.stream.filters.GroupFilter` for finding elements which have a particular group name.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter Shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filtering elements by offset or by class is so common, that `music21` has some shortcuts for adding filters to it, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Rest rest> 1.0\n"
     ]
    }
   ],
   "source": [
    "sIter4 = s.iter\n",
    "restIterator = sIter4.getElementsByClass('Rest')\n",
    "restOffsetIterator = restIterator.getElementsByOffset(0.5, 4.0)\n",
    "for el in restOffsetIterator:\n",
    "    print(el, el.offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Easier still, since each of these methods returns a new filter object, you can chain them right in the for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Rest rest> 1.0\n"
     ]
    }
   ],
   "source": [
    "for el in s.iter.getElementsByClass('Rest').getElementsByOffset(0.5, 4.0):\n",
    "    print(el, el.offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And you can even skip the `s.iter` step for getting an iterator for the most common of these filters, and `music21` will recognize what you want to do and create the iterator for you:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Rest rest> 1.0\n"
     ]
    }
   ],
   "source": [
    "for el in s.getElementsByClass('Rest').getElementsByOffset(0.5, 4.0):\n",
    "    print(el, el.offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shortcut methods that `music21` exposes on Iterators include:\n",
    "\n",
    "* :meth:`~music21.stream.iterator.StreamIterator.getElementById` which adds an `IdFilter`\n",
    "* :meth:`~music21.stream.iterator.StreamIterator.getElementsByClass` which adds a `ClassFilter`\n",
    "* :meth:`~music21.stream.iterator.StreamIterator.getElementsByGroup` which adds a `GroupFilter`\n",
    "* :meth:`~music21.stream.iterator.StreamIterator.getElementsByOffset` which adds an `OffsetFilter`\n",
    "\n",
    "And there are also properties (that is, written without parentheses) which add certain filters:\n",
    "\n",
    "* :attr:`~music21.stream.iterator.StreamIterator.notes` which filters out everything but `Note` and `Chord` objects\n",
    "* :attr:`~music21.stream.iterator.StreamIterator.notesAndRests` which filters out everything except `GeneralNote` objects\n",
    "* :attr:`~music21.stream.iterator.StreamIterator.parts` which returns all the `Part` objects\n",
    "* :attr:`~music21.stream.iterator.StreamIterator.voices`\n",
    "* :attr:`~music21.stream.iterator.StreamIterator.voices` which returns all the `Voice` objects\n",
    "* :attr:`~music21.stream.iterator.StreamIterator.spanners` which returns all the `Spanner` objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Custom Filters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating your own filter is pretty easy too.  The easiest way is to create a function that takes in an element and returns True or False depending on whether the object matches the filter.\n",
    "\n",
    "We will create a filter to see if the element has a `.pitch` attribute and then if that pitch attribute has a sharp on it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Note C#>\n"
     ]
    }
   ],
   "source": [
    "def sharpFilter(el):\n",
    "    if (hasattr(el, 'pitch') \n",
    "            and el.pitch.accidental is not None\n",
    "            and el.pitch.accidental.alter > 0):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "sharpIterator = s.iter.addFilter(sharpFilter)\n",
    "\n",
    "for el in sharpIterator:\n",
    "    print(el)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ".. note::\n",
    "   Before `music21` v.4.0.6, filters must take in two arguments, \n",
    "   but now the second one, being the iterator object itself,\n",
    "   can be omitted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recursive and Offset Iterators\n",
    "\n",
    "`Music21` comes with two other iterators that let you do powerful operations.  The most commonly used is the :class:`~music21.stream.iterators.RecursiveIterator` which burrows down into nested Streams to get whatever you want.  Let's load in a nested stream:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.metadata.Metadata object at 0x11889cef0>\n",
      "<music21.stream.Part Soprano>\n",
      "<music21.stream.Part Alto>\n",
      "<music21.stream.Part Tenor>\n",
      "<music21.stream.Part Bass>\n",
      "<music21.layout.StaffGroup <music21.stream.Part Soprano><music21.stream.Part Alto><music21.stream.Part Tenor><music21.stream.Part Bass>>\n"
     ]
    }
   ],
   "source": [
    "bach = corpus.parse('bwv66.6')\n",
    "for thing in bach:\n",
    "    print(thing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Right, we remember that often the actual notes of a piece can be hidden inside Parts, Measures, and Voices.  A recursive iterator gets to them, and they're created by calling `recurse()` on a stream."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<music21.stream.iterator.RecursiveIterator for Score:0x1188ab8d0 @:0>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recurseIter = bach.recurse()\n",
    "recurseIter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add a filter for only E#s to it, and look into it.  Instead of checking to see if each element has a `.name` attribut we'll put a `try...except` clause around it, and if it does not have the `.name` attribute (and thus raises and `AttributeError` we will return False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Note E#> 9\n",
      "<music21.note.Note E#> 3\n",
      "<music21.note.Note E#> 7\n",
      "<music21.note.Note E#> 7\n",
      "<music21.note.Note E#> 2\n",
      "<music21.note.Note E#> 6\n"
     ]
    }
   ],
   "source": [
    "def eSharpFilter(el):\n",
    "    try:\n",
    "        if el.name == 'E#':\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    except AttributeError:\n",
    "        return False\n",
    "\n",
    "eSharpIterator = recurseIter.addFilter(eSharpFilter)\n",
    "\n",
    "for el in eSharpIterator:\n",
    "    print(el, el.measureNumber)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the measure numbers don't keep increasing.  That's because the recurse iterator finishes one part before returning to the next.  We can use the fancy `.getContextByClass` to figure out what part it is in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.note.Note E#> 9 Soprano\n",
      "<music21.note.Note E#> 3 Alto\n",
      "<music21.note.Note E#> 7 Alto\n",
      "<music21.note.Note E#> 7 Tenor\n",
      "<music21.note.Note E#> 2 Bass\n",
      "<music21.note.Note E#> 6 Bass\n"
     ]
    }
   ],
   "source": [
    "for el in eSharpIterator:\n",
    "    pId = el.getContextByClass('Part').id\n",
    "    print(el, el.measureNumber, pId)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(as an aside, `.measureNumber` is just a shortcut for `.getContextByClass('Measure').number`, so we are actually looking up two contexts)\n",
    "\n",
    "Another useful iterator is the OffsetIterator, which returns lists of elements grouped by offset.  Let's add some more things to our Stream before we see how it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<music21.clef.TrebleClef> 0.0\n",
      "<music21.key.KeySignature of 3 sharps> 0.0\n",
      "<music21.note.Note C#> 0.0\n",
      "Trumpet 1.0\n",
      "<music21.note.Rest rest> 1.0\n",
      "<music21.note.Note D> 3.0\n",
      "<music21.note.Rest rest> 4.5\n"
     ]
    }
   ],
   "source": [
    "s.insert(0, clef.TrebleClef())\n",
    "s.insert(0, key.KeySignature(3))\n",
    "s.insert(1, instrument.Trumpet())\n",
    "\n",
    "# normal iterator\n",
    "for el in s:\n",
    "    print(el, el.offset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike with the normal `StreamIterator` or the `RecursiveIterator`, there is no method on `Stream` to create an offset iterator, so we will create one directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 [<music21.clef.TrebleClef>, <music21.key.KeySignature of 3 sharps>, <music21.note.Note C#>]\n",
      "1.0 [<music21.instrument.Trumpet 'Trumpet'>, <music21.note.Rest rest>]\n",
      "3.0 [<music21.note.Note D>]\n",
      "4.5 [<music21.note.Rest rest>]\n"
     ]
    }
   ],
   "source": [
    "oIter = stream.iterator.OffsetIterator(s)\n",
    "for elementGroup in oIter:\n",
    "    print(elementGroup[0].offset, elementGroup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## From Iterator to Stream\n",
    "\n",
    "From either a `StreamIterator` or a `RecursiveIterator` a new `Stream` object can be generated by calling `.stream()` on it.  On a `RecursiveIterator`, this does not put the elements into substreams."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{8.0} <music21.note.Note E#>\n",
      "{10.0} <music21.note.Note E#>\n",
      "{23.0} <music21.note.Note E#>\n",
      "{25.5} <music21.note.Note E#>\n",
      "{27.0} <music21.note.Note E#>\n",
      "{34.5} <music21.note.Note E#>\n"
     ]
    }
   ],
   "source": [
    "onlyESharps = bach.recurse().addFilter(eSharpFilter)\n",
    "esharpStream = onlyESharps.stream()\n",
    "esharpStream.show('text')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Derivation of <music21.stream.Score 0x118c740b8> from <music21.stream.Score 0x1188ab8d0> via 'eSharpFilter'>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "esharpStream.derivation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be useful if you'd like to do plots on the resulting stream, though this one is a bit too obvious..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "tags": [
     "nbval-ignore-output"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtYAAAL9CAYAAAAPeyEzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdfbzX8/348efp+px0JdKVLpSKaqjoKxdZIcnFFmYyunC1GX3Nz+VmlNlcC5vv5qvVMfYdQ5sQ2YjYkEQ7kcxUlCxSoqTS+/dH3/P5djqny/PSp6P7/XY7t9vpffl6f867bo/z6f15vwuyLMsCAAColGr5HgAAAHwdCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwhh3MkCFDoqCgYKNfDRo0iF69esWoUaNixYoV5baxcOHC6NixYxx44IEVzv+qtG/fvsw4i4uLv9L9TZs2LS644ILYZ599onHjxlGrVq1o3LhxHHDAAXH22WfHfffdF4sXLy6zzogRI8qM8bDDDvtKx7gtFRcXb/CcGTFiRLnlN7RsmzZtyiyXr/MJIDVhDTuYn//851FSUhLXXHNNblpJSUnua/LkyXHVVVfFrFmz4sILL4wDDjggPvzwwzLbmDx5crz11lvx4osvxuuvv15uH6UBljoqH3/88SgpKYkePXok3e76li1bFqeddlr06NEjpk6dGueff36MHz8+Xnzxxbj77rvjkEMOiT/+8Y9xyimnRNOmTWPIkCG5dc8999xyr+/Xxbe+9a0oKSmJiRMn5qaNGTMmSkpK4txzzy23fOk5VfrzOv7446OkpCSefPLJMstt6nzaGqURP2fOnCTbA9gcNfI9AGDbatGiRbRo0SKmTp2am9alS5cyyxxyyCFx3HHHRZcuXaKkpCSGDBkSjz32WG5+v3794thjj42GDRvGvvvuu83Gvueee0ZERN26db+yfSxdujS++c1vxrRp0+IXv/hFXH755WXmd+vWLY455pj40Y9+FIcffnjMmjUrnnnmmdz8Jk2aRJMmTcq8vl8XDRs2jIYNG8ZOO+2Um9a2bdty50+p0umlP6+GDRtWuGy+zieA1IQ1UKH27dvHKaecEsXFxTFhwoR45513Yo899oiIiHr16sX48ePzPMKvxrBhw2LatGlx6qmnlovqdbVs2TL++Mc/CsEEvs7nE7BjcSkIsEGdO3fOff/aa6/lcSTbxqRJk+Khhx6KgoKC+NnPfrbJ5b/xjW9E3759t8HIAKgKhDWwQbVq1cp9v3r16oiIaNOmzQY/QFh6bfXQoUMjIuLZZ5/d5Af5li5dGldffXXst99+Ua9evahTp060bds2TjjhhLj77rtj+fLlGx3jm2++GSeeeGLssssuUVhYGN26dYs//vGPW3W8t99+e0RE9OjRI9q2bbtZ6/z0pz+NSy+9dIv2s3LlynjwwQfje9/7Xuy5555Rp06dKCoqir333jsuvvjicte0r+ujjz6Kn/70p7HPPvtEo0aNorCwMDp16hTDhg2Lhx9+OFatWlVm+TVr1sQDDzwQffr0iZYtW0atWrWiWbNm0b9//7j11lvjgw8+2KKxp7ax86nUlhxz6XZKtW3btsz2K7rmety4cdG/f//Yddddo3bt2tGyZcs49dRTY9q0aRsd++TJk+Ooo46Khg0bRlFRUey1115x5ZVXxvLly8sd15///OeYN29euQ9yzpkzJ5566qk48sgjo3HjxuU+DLo158rzzz9fbj8Ra/9+fuMb34jCwsJo27Zt/PjHP47PP/88IiI+/vjj+MEPfhDNmjWLwsLC6NmzZ/z1r3/d1I8PWF8G7JDGjh2bRUS2sX8GzjvvvNwy06dPz7Isy2bNmpWVlJRkPXr0yCIiGzt2bG75xYsXZyUlJdk111yTRUTWo0ePrKSkJPf1zjvvlNn+rFmzsjZt2mTVq1fPLrjgguy5557LnnvuueyWW27Jdt111ywissMPP7zcuHr37p1FRHbJJZdk++67b/aHP/whe+mll7Jf//rXWb169bKIyMaNG7dFr8fq1auz+vXrZxGRnXvuuVu0bkVKX9/evXuXm/fII49kEZE1bdo0+9WvfpW9+OKL2ZNPPpldfPHFWe3atbMWLVpkc+bMKbfevHnzsubNm2e1a9fOrrnmmmzy5MnZ3//+9+y2227LmjRpkkVEVlxcXGad008/PYuI7Nhjj80ee+yxbOrUqdm4ceNyr+Fhhx22xcc2e/bs3HkxadKkTS5fuq/BgweXm7ex82lrjrn0XCsd38SJE8ucgytXrswtu3r16ux73/teFhHZIYcckj388MPZ1KlTs+Li4qx169ZZtWrVsttvv73CYxo7dmxWUFCQ1atXL7vpppuyKVOmZE8++WT27W9/OzvooIOy5s2bZxGRjRkzJispKcmWLl2arVq1qtz4rrnmmqx79+7ZQw89lE2ZMiW74oorsojIrrrqqizLtu5cWbZsWVZSUpJNnDixzH6GDh2aPf/889kTTzyR9e3bN4uIbODAgdmyZcuyo48+Orvnnnuyl156Kbvllluy2rVrZzVr1symTp26yZ8v8H+ENeygNhXWH3/8cdaoUaMsIrJu3bqVm18aS+uH0LrbrigqSy1btizr0KFDFhHZTTfdVG7+tGnTspo1a1a4jdJ977TTTtns2bPLzBs9enQWEVnPnj03uO+KvP3227nXo6LxbKnNCetp06aVm1dcXJxFRHbMMceUm/ef//mfWURkV1xxRbl5L774Yrmfx6uvvppFRNa6devsyy+/LLP8ypUrs65du270Z7QhKcN6/WXWP5+29JhLlY5v/fNjXT/5yU9yvwB+8cUXZebNnTs3q1evXlZQUJA98cQTZea9+eabWe3atbOIyB5//PEy89asWZMde+yxm3x9Sue3b98+W7p0aZl5e+65Z7mw3tJzJcvK/pxOOOGEMvOWL1+eNWzYMIuI7KSTTspeeeWVMvOvvvrqLCKyU045pcJtAxVzKQhQxtKlS2PSpEnxzW9+MxYvXhy77LJL3HPPPcn389vf/jbeeuutaNy4cQwfPrzc/P322y+++c1vbnQbAwYMKHdP5NJ1XnnllVi5cuVmj2fRokW57+vVq7fZ622NDh06xKhRo2K//fYrN+/UU0+NWrVqxYQJE+KTTz4pM+/NN9+MiIrvitKzZ8/4zne+E7vvvnu55QsLC6NatbL/3NesWTPOP//8OPDAAyt1LH379o0aNWps9OvZZ5/d6u1v6TFvroULF8bNN98cERGXX355mcueIiJatWoVQ4cOjSzLyl3qc9NNN8UXX3wR3bp1i6OOOqrMvIKCgrjiiis2exznnntuufNt8uTJccEFF0TE1p8r6zvnnHPK/Ln0co+IiPnz50e3bt3KzC/97MDf//73zT4WwF1BgIioUeP//in48ssvIyKiQYMGMWzYsLj66qujRYsWyff54IMPRsTaW/vVrFmzwmV++ctfxpIlSza4je7du5eb1rx584hYe034okWLolmzZglGm1aHDh2iQ4cOFc6rUaNGNGvWLObOnRtvv/12mWNs3759TJw4MW688cbo2LFjHH/88WWC+f777y+zrfbt20fE2ji98MIL46c//Wk0atQoN/+ss86q9LGMHj069t9//40uM3To0K2+/eCWHvPmmjBhQu5hNH369KlwmcMPPzxuv/32mD59evzrX/+Kdu3aRUTkbj25ofu0d+/ePWrXrh1ffPHFJsfRq1evctOaNm2a+35rz5X1VRTmu+666wbnNWnSJCIiFixYsPEDAMoQ1kCZO34UFBRE/fr1o0WLFuXe5UxpxowZERHl3nFe14aColTjxo3LTatTp07u+80Jm1KlkRER8emnn272elvrjTfeiNtuuy0mT54c8+bNixUrVkSWZRHxf7/cfPbZZ2XWueyyy+LRRx+NuXPnxsCBA6NFixbxrW99K44//vjo27dvuZ9Xjx494owzzojf/va3MWrUqPiv//qvOPLII+P444+Pb3/727HzzjtX+jg2dh/rUpW57/iWHvPmKikpiYj/uzd3RdY9N0tKSqJdu3bxySef5GKzVatWFa5XvXr1aNy4cbz//vubHMcuu+yyyWW25lxZX0U/6+rVq29wXukv21vyvz6Au4IAsfZBHqVfnTt3jt133/0rjeqItZecRKz9L+mtlXKMrVq1igYNGkRExDvvvJNsuxX505/+FPvuu2+MGTMm+vXrFw8++GBMmzYtXnvttXjttddy77qXxlOpli1bxmuvvRYjRoyI3XffPebPnx933HFHHHnkkbHHHnvE3XffXW5fo0ePjgcffDB69+4dK1eujEceeSTOPPPMaNGiRZx99tnb5JeIytiaY94cm3P+FRUV5b4vvdRi3ddrY+tu6H9h1lcatxuytefK+jb2d+Wr/rsOOxJ/m4C8qF+/fkRE7nZf+Va9evXcdaVf5VMTV65cGWeddVasWrUqfvKTn8Stt94a/fr1i65du+Z+udlYlDVs2DCuuuqqmDt3bvztb3+L4cOHR6NGjWLu3LkxZMiQ+OUvf1lunRNOOCGeeeaZePfdd2PUqFGx7777xooVK+Kuu+6Kww8/PPeu5/Zqa455U0rPv43dznHdeaW/dK17PfTGzt31b3u4NSp7rgDbnrAG8qJr164RETF79uwNLvPFF1/EZ599tsl341K58MILIyLi5ZdfrvB+x+v79NNPo0OHDtGyZcvch+w2paSkJPdByWOOOWarx1pQUBC9evWK2267LebMmZO73veWW27Z4DotW7aMCy64IF599dXcPbunTJkSzz///FaPY1vammPekNLz75NPPonFixdXuMy650Dp8g0aNMhdtz937twK1/vyyy/LfBh2a6U6V4BtR1gDyZVen7luEC9btiwefPDBXICedNJJERHx3HPPbfDdvT59+kTbtm2TvPu3OQ466KAYNGhQZFkWV1555SaXv+OOO+Kf//xndOjQITp16rRZ+1j3NanoF4bVq1dv8ANjAwcOjJ/85CflptevXz93F4l1H/hy//335z7AuL7zzz8/d21xvh8SszFbesylSi+xWPc1fuaZZ2LixIkRsfaOMqXX4z/11FMV7rv0ASn77LNP7oOLpeuWbq8i06ZN26Lr+zekMucKkB/CGkhut912i4i1T3Mr9dprr8VJJ52Uu33XsGHDolOnTvHxxx9X+F/5kyZNihdeeCGGDh1a7lZoX6XRo0dHz54945577okbb7xxg8s9/PDDubts3HnnnZu9/S5duuQuQ7jvvvvKzR8zZswGPzD28ccfx0MPPZS7m8W63nrrrYhY+4HFUp9//nn861//qjAAP/jgg1i6dGkUFBRs9G4S+balx1yqonPwrLPOip///OcRsfbDqhdddFFERPziF78o95q/++67MXbs2CgoKIjrr7++zLyLLrooateuHa+++mo88cQT5fb9i1/8Isl1y5U5V4D8cFcQ2MHMnz8/Fi9eHPPnz89NK71DR926dTf5KO+33norVq5cGcuWLcttb8aMGdGyZcvcO6C9evWKhg0bxsyZM+Oee+6Jdu3axZVXXhlFRUVx+OGHR8TaD36NHz8++vXrF5dccknMnz8/Bg4cGBFr7+N73XXXxUEHHRQ/+9nPcvuePXt2LFu2rNy+27ZtG3Xr1s2Nbd2xfvbZZ9GxY8fNvha1sLAwJk2aFD/4wQ/i0ksvjfHjx8fQoUNjr732ioi1H2y8//7745FHHok99tgjHnroodhzzz1z6y9cuDAWLlyYe32XLVsWM2bMyL22derUiZtuuinOPvvsuPXWW2P58uVxwgknRO3atePxxx+P22+/PXerttmzZ8cuu+ySO76CgoKYNWtW9OnTJ4YPHx7t2rWL5cuXx7PPPhvXXnttNGjQIG699dbcWEofZX3iiSfGJZdcEj179oyioqJ4880344Ybbog1a9bEFVdcscF3tde3ZMmSmDdvXpm7XZSOsUmTJrlbtJUqPa9Kf15LliyJGTNmRK1atXJ3fNnU+bSlx1xqwIABcdddd8WoUaNi+PDhMWnSpHj77bfL3M95xIgRMWfOnLj33nujb9++cfHFF0fLli1jxowZceWVV8ayZcvitttui379+pXZdseOHeM3v/lNDBs2LL7zne/EiBEj4tBDD40lS5bEb37zm2jQoEHsvvvuFV4qUvqalCo9Rxs1alTutpZbe67UqlUrZs2aVebntO7rXnqOlt7KcuHChWVe8xkzZpRbNyI2efcXIDzSHHY0gwcPzj2Nbf2vzXkKX+vWrStcd/2n302ePDnr1atXVlhYmNWrVy/7j//4j+wvf/lLue198skn2dVXX53ts88+WVFRUVa7du2sc+fO2dVXX50tX768zLKlT+db/6v06XYbGtvGnr63MdOmTct++MMfZnvvvXdWr169rGbNmlnTpk2zfv36ZXfeeWe2YsWKcutcddVVm/XaTpgwIevbt29Wv379rEaNGlmLFi2yU045JXvttdfKHUfp8S1cuDAbNWpUduSRR2bNmjXLatasmdWuXTvr0KFD9sMf/rDco61Xr16djR8/Phs8eHDWsWPHrKioKKtRo0a22267ZQMGDMgeeeSRLXo91n1a5/pfpU8KXNeGlm3dunVumU2dT1t6zKWWLFmSDRkyJNt1112zWrVqZe3atcuuvPLKbNWqVeWWHTduXNavX7+scePGWc2aNbPmzZtnp5xyyiYf5z158uSsX79+Wf369bOioqKsa9eu2S233JJ9+eWX2e67755FRPa3v/1ts16TjT2VckvPlXWfuFjR676hc7T0Nd/QGIFNK8iybfSpIADYQdSvXz8+/fTTeOutt8r8jwbw9eYaawDYQtdee23uGu/1vf322/Hpp5/GLrvsstmX2QBfD8IaALbQzTffvMEPt5ZOP++883LXuQM7BpeCAMAW2mWXXWLRokW5DzA2adIkPvjgg/jd734X9913Xxx11FExfvx4D3CBHYywBoAt9MILL8RDDz0UkyZNivfffz8WLVoUdevWjX322SdOO+20GDJkyCYfVw58/VSpsO7UqVM0bdq0zLQFCxZEnTp1Yvr06XkaFQAAVLH7WDdt2rTcgw4GDx4cHTt2zM+AAADgf1Wpd6xnz55d5uEVn332WbRo0SJmzpwZzZs3z+PIAADY0VWpu4Ks/0S4Bx54IA4++GBRDQBA3lWpsF7f2LFjY9iwYfkeBgAAVK1LQdb1r3/9K3r16hXz5s1zOyMAAPKuSn14cV3FxcVx6qmnblZUd+/evcLps2fPjv79+8fvf//71MMDAGAHUyXDOsuyuOeee+LRRx+t1HZWrFgRJSUlMW/evEQjA6iaVq1aFRHhfwABIqJly5ZbtV6VDOunn346dtttt+jSpctmLf/KK69UOL30neytffEAvi5K32Dw7yHA1quSH170oUUAALY3VS6sly5dGk888USccsop+R4KAADkVLlLQerXrx8fffRRvocBAABlVLl3rAEAYHskrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACCBKhfWc+fOjZNPPjn69OkTXbt2je7du8ekSZPyPSwAAHZwVSqsP/roo+jTp0/84Ac/iKeffjr+8Y9/xB577BGvv/56vocGAMAOrka+B7AlbrjhhujZs2ccdthhERFRUFAQN998c6xZsya/AwMAYIdXpd6xfuihh+LQQw8tM61Vq1bRpk2b/AwIAAD+V5UJ62XLlsU777wTX375ZZx66qlx0EEHxRFHHBEPPPBAvocGAABV51KQJUuWRETEFVdcEU899VR069YtpkyZEr17945Vq1bFoEGDNrhu9+7dK5w+c+bMaN++fcybN+8rGTNAVbFq1aqICP8eAkREy5Ytt2q9KhPW1atXj4iIY445Jrp16xYREQcccEB8+9vfjltuuWWjYb09+unlo/M9BACA7d7Prj0z30PYbFUmrHfdddeoXbt2ud8gWrduHRMnTtzouq+88kqF00vfyd7a30oAAPhqVaVOqzLXWFevXj0OOuigWLBgQZnp//73v6NVq1Z5GhUAAKxVZcI6IuLSSy+Nhx9+OGbPnh0Rax8W86c//SmGDx+e55EBALCjqzKXgkREHHnkkXHHHXfECSecEEVFRbF69eq48cYbY+jQofkeGgAAO7gqFdYREYMGDapyH1QEAODrr0pdCgIAANsrYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAggRr5HsCWKC4ujuuuuy6aNm1aZvrDDz8cDRo0yNOoAACgioV1RMRll10WQ4YMyfcwAACgDJeCAABAAsIaAAASqHJh/eijj0afPn3i4IMPjhNPPDFefvnlfA8JAACq1jXWu+22W7Rv3z5GjBgRderUid///vdx4IEHxvPPPx//8R//scH1unfvXuH0mTNnRvv27WPevHlf1ZABAKiEfHRay5Ytt2q9KvWOdf/+/eO6666LOnXqRETEqaeeGgceeGBcd911eR4ZAAA7uir1jnVF2rVrF1OnTt3oMq+88kqF00vfyd7a30oAAPhqVaVOq1LvWF9++eWxfPnyMtPmz58frVq1ytOIAABgrSoV1i+88EL89re/zf352WefjaeffjrOPffcPI4KAACq2KUgl112Wfzyl7+MBx54INasWROrV6+O+++/P4455ph8Dw0AgB1clQrro446Ko466qh8DwMAAMqpUpeCAADA9kpYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEkga1r/73e82Ov/EE0+MM844Iz744IOUuwUAgLxLGtZDhw7d6PxevXrFK6+8Euecc07K3QIAQN4lDessyzY6/8ILL4y//vWvMXny5JS7BQCAvEsa1gUFBRudv3LlypgyZUrUrFkz5W4BACDvKhXWI0eOjOrVq+e+siwr8+f1vwoLC+PYY4+Nfv36pRo/AABsF2pUZuU2bdrEoYcemvvz5MmTy/x5XQUFBdGoUaPo0aNHnH/++ZXZLQAAbHcqFdaDBw+OwYMH5/5crVq1mDRpUqUHBQAAVU3Sa6zHjh2bcnMAAFBlJA3rdd+93pirr7465W4BACDv8vLkxZEjR+ZjtwAA8JWp1DXWFRk3blzce++98c9//jOWL1++yXtbAwDA10HSsL7tttviRz/6UURE7LzzzrHTTjtt8t7WAADwdZA0rG+99dY4+eST47bbbosmTZpscLlq1fJyBQoAAHxlkhbuggUL4tZbb91oVEdEXHXVVSl3CwAAeZc0rNu1a63vFEwAABhESURBVLdZ11QLawAAvm6ShvVll10W119//SaXq169esrdAgBA3iW9xjrLsnj99ddjv/32i+OOOy6aN28ehYWFKXcBAADbpaRhPWTIkNz306dPj4god1eQLMvcKQQAgK+d5Pex3tRjzbMsizPOOCP1bgEAIK+Sh/XmPNZ82LBhqXcLAAB5lfx2e5tjzZo1KXcLAAB5lzSsd9ttt81abty4cSl3CwAAeZeXRyCedNJJ+dgtAAB8ZZJeY+3aaQAAdlRJw7q4uHizlnO7PQAAvm6S3xVk9uzZ5aYtX7485s+fH+PGjYt58+bFrbfemnq3AACQV0nDesCAAdG6desK5+21115x+OGHx+jRo+Puu++OkSNHptw1AADkVdIPLz7yyCObXOakk06KMWPGpNwtAADk3Ta/K8iCBQvio48+2ta7BQCAr1TSS0HefffdDc5btmxZzJo1K372s5/F3nvvnXK3AACQd0nDuk2bNpu840ft2rVj/PjxKXcLAAB5l/yuIKeffnq5aQUFBVFYWBh77rlnnHDCCbH77run3i0AAORV8rAeO3Zs6k0CAMB2L+mHFydNmpRycwAAUGUkfce6d+/eue/XrFkTs2bNiiVLlkSjRo2iY8eOnrgIAMDXVvLb7a1YsSIuueSSaNy4cXTp0iUOPvjg6Ny5czRu3Dguu+yyWLFiRepdAgBA3iV9x/rzzz+PPn36xEsvvRQFBQXRtGnTqFu3bixbtiw++OCDuOGGG2Ly5Mnx9NNPR506dVLuGgAA8irpO9Y33nhjzJw5M37zm9/E4sWLY/78+fHWW2/F/Pnz4+OPP45f//rX8cYbb8RNN92UcrcAAJB3ScP6vvvui7Fjx8bZZ58d9evXLzOvQYMGcc4558SYMWPif/7nf1LuFgAA8i5pWM+ZMyeOPvrojS4zYMCAmD17dsrdAgBA3iUN68LCwvjwww83usy///3vKCoqSrlbAADIu6Rh3atXr7joooti9erVFc5fvXp1XHTRRXHwwQen3C0AAORd0ruCXH755dG7d+94+eWXY+DAgdGpU6fcXUFmzpwZ48aNi3nz5sVzzz2XcrcAAJB3ScO6V69ecffdd8fZZ58dN998c5kHwmRZFnXr1o177703evbsmXK3AACQd0nDOiJi0KBB0adPn7j77rtj6tSp8cknn0TDhg3jgAMOiNNPPz2aNGmSepcAAJB3ycM6IqJp06Zx6aWXfhWbBgCA7VKlP7x45plnxsCBA2PgwIExduzYCpdZtGhR7L///jFx4sTK7g4AALZLlQrradOmxZgxY+LPf/5zfPjhh9GiRYsKl6tVq1a88847MWDAgBg9enRldgkAANulSoX1o48+GnXq1In7778/nnvuuTjyyCMrXK5evXrx3nvvxfnnnx/f//73Y9q0aZXZLQAAbHcqFdbPPfdcnH/++XHSSSdtctmioqIYNWpUnHTSSXH77bdXZrcAALDdqVRYv/HGG3H66adv0To/+tGPYvLkyZXZLQAAbHcqFdaLFi2KNm3abNE6e++9d7z//vuV2S0AAGx3KhXWRUVFsWbNmi1aJ8uyqFWrVmV2CwAA251KhXX79u3j5Zdf3qJ1pkyZEnvuuWdldgsAANudSoV1//794+qrr97sd63XrFkT11xzTRx33HGV2S0AAGx3KhXWw4cPj+nTp8fxxx8f8+fP3+iy7733Xhx33HExY8aMGD58eGV2CwAA251KPdK8cePGce+998a3vvWtaNu2bfTu3Tv233//aNmyZRQWFsbnn38e8+bNiylTpsTkyZOjevXqMX78+GjUqFGq8QMAwHahUmEdETFgwICYOHFinH766fHUU0/F008/XW6ZLMuidevWce+998ZBBx1U2V0CAMB2p9JhHRHRp0+feOedd+IPf/hDPPnkkzFr1qxYunRpNGjQIDp06BD9+/ePk08+OWrWrJlidwAAsN1JEtYREbVq1YrBgwfH4MGDU20SAACqjEp9eBEAAFhLWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQgLAGAIAEhDUAACQgrAEAIAFhDQAACQhrAABIQFgDAEACwhoAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAYAgASENQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEhDWAACQQEGWZVm+B5EvO++8c6xYsSL22muvbb7vuXMWbPN9AgBUNa3bNNvm++zUqVP8/ve/3+L1anwFY6ky6tevn7d95+MkAdiQmTNnRkTk5Y0GgK+LHfodawDW6t69e0REvPLKK3keCUDV5RprAABIQFgDAEACwhoAABIQ1gAAkICwBgCABNwVBAAAEvCONQAAJCCsAQAgAWENAAAJCGsAAEhAWAMAQALCGgAAEqiR7wEAsO3Mnj07hg4dGi+++GI0bdo02rRpU2b+iy++GCtWrCgz7d///nfstttu23CUAFWT+1gD7IDatGkTQ4YMiREjRpSbPmfOnDLTRo8eHWeeeea2GxxAFeVSEABy7r777tz3Dz/8cO77J598Mh/DAahShDUAMWfOnDjssMOid+/euWkLFiyIO++8M6699tp49NFH8zg6gKpBWANQzn333RdXXHFFvPDCCzFw4MC4/fbb8z0kgO2eDy8C7KCKi4vjmWeeiYiIFStWRJ06dXLzdt1117jyyitj+PDhMXr06DyNEKBq8Y41wA5qyJAh8cwzz8QzzzwT9913X5l5ffv2jfr160dExLvvvhtnnXVWPoYIUKV4xxqAaNOmTe7d64iIL7/8Ml544YW4/fbbY9GiRfHggw/mb3AAVYSwBiDnsccei969e8ePf/zj+Mc//hFjxoyJqVOnxv7775/voQFs94Q1ADk33nhjdO7cOa6//vq4//77Y999942VK1fme1gAVYKwBtiBvPPOOzFo0KBYsGBBjB49Op544oky8994442IiCgsLIyCgoKIiDjggAO2+TgBqiJPXgQAgATcFQQAABIQ1gAAkICwBgCABIQ1AAAkIKwBACABYQ0AAAkIawAASEBYAwBAAsIaAAASENYAAJCAsAbYAm3atImCgoIKvwoLC6Nz584xYsSIWL58eZn1Jk2aFA0bNoxrr7223DaLi4tjxIgRlR5bp06dcmMZMmRIpbe3rhdeeCGGDBkSe+yxRxQWFkbdunWjY8eO8d3vfjfuuuuu+PDDD3PLjhgxoszrArCjENYAW2DOnDmRZVnuz1mWRZZlsWrVqpg+fXp07949Ro4cGYccckiZuF64cGF88skn8e6775bbZnFxcYwcObLSY3vzzTdj9uzZld7OulavXh3f//73o3fv3tGkSZN47LHHYsmSJfH222/Hr371q/jwww/j7LPPjubNm8fTTz8dEWvDOsuy6N27d9KxAGzvhDVAAjVq1IgOHTpEcXFxdO3aNaZNmxZ33HFHbv7JJ58c77//fplpVcHZZ58dd955ZxQXF8cNN9wQe+21V9SuXTuaNWsWRxxxRPzlL3+JY445JlavXh1Lly7N93AB8kpYAyRUrVq13Du1kydPLjOvWbNmUa1a1fln97HHHouxY8fGEUccEYMGDapwmWrVqsWoUaO28cgAtk9V5194gCrqsMMOy11vfNhhh+WmFxcXR0FBQTz77LMREWWuSy4uLi6zjQkTJkTfvn2jQYMGsdNOO0Xnzp3je9/7Xjz++OMb3O9LL70Uhx56aBQVFcUuu+wS55xzTnz++eebPe6bbropIiJOO+20jS7Xvn37GDlyZLRr126ztjtp0qQYNmxYdOrUKYqKiqJhw4ZxxBFH5C4lWd+bb74ZgwYNilatWkVRUVF07NgxTjvttHj00UfLLPfxxx/HpZdeGh06dIiioqJo1apVHH300TFmzJhy17wDfCUyALZYRGQV/RP65ZdfZl27ds0iIrvxxhvLrdO7d+9y6/Tu3bvCbZW68cYbs4jIzjvvvGzBggXZ0qVLs0cffTRr1qxZFhHZ4sWLc8vOnj07i4isV69e2VFHHZW98cYb2eLFi7NRo0ZlEZH98Ic/3Kzj++yzz7KaNWtmEZHNnDlzs9bZ3OPq3Llztu+++2ZTpkzJPv/882zOnDnZeeedl1WrVi0bP358mWXfe++9rH79+lmfPn2yN998M1uxYkU2ffr07OCDDy6z7TVr1mQ9evTIWrRokT333HPZ8uXLs/feey8755xzsojIJk2atFXHALAlhDXAVlg/rFevXp3NmjUrO/3007OIyPbbb79s2bJl5dbZ0rB+9dVXs2rVqmUHHXRQuXkPPPDABsO6Zs2a2QcffFBm+c6dO2cNGzbcrOP7xz/+kTvGTz/9dLPWWd+GjuuEE07IXn755XLT99tvv6xLly5lpt12221ZRGSPPPJImelvv/12mW1Pnz49i4js//2//1dmuTVr1mStWrUS1sA24VIQgEoovXSjRo0a8Y1vfCOmTp0aV155ZTz//PNRVFRU6e3/93//d6xZsya++93vlpvXv3//OPPMM6N27drl5vXs2TN22223MtM6duwYS5YsKXNrvA1Z94OIhYWFWzHyDXvwwQejR48e5aZ36dIlZsyYUWbfpbfrGzduXKxatSo3vV27dvHPf/6z3HJ//etfY9GiRWWm//3vf4+ePXsmPQaAighrgErI/vd2e1mWxYoVK+L111+PkSNHJonqiIiXX345ItZG8frq1q0bd911V4Xh27x583LTdtppp4iIzbreuEGDBrnvt+S67M2xcOHCuPjii6Nz586x00475X45ueeeeyIiYvHixbllTz755GjWrFmMHTs22rVrF5dddllMnTo1ItZe212qS5cucfjhh8f06dOjbdu2ccYZZ8Tjjz8eq1atihYtWiT/5QCgIsIaYDu2ZMmSiFgb0VuiopAsfVc3W+c+3BvStm3bqFmzZkREzJs3b4v2vTEffvhhdOvWLe6444748Y9/HO+++27uF5PBgweXG1+TJk3itddeiwsvvDCWL18e119/fey///7RtWvXmDBhQpljmzBhQowaNSqaNWsWY8aMiaOPPjp23333uPnmmzfrmAEqS1gDbMcaNmwYERHLli3bpvutW7duHHLIIRERMWXKlI0um2VZfPTRR/Hpp59ucrt33XVXzJ8/P77//e/HqaeeGjvvvPMm12nSpEnc/P/bu59Q+NY4juOfqxilEaHGxmQhC6WmZCEbG/xip4RSQyHlX2jsjEaKBWE/SUlG2CmLkZWykIUQQihm1KT8SSPpuQv93J9rLt37O9Kt96vO5pznPM85s/p0+s73GR1VOBzWysqKqqurtbu7q8rKyjctDePj49XV1aWDgwNtbW2pu7tb9/f36u3t1dDQ0KfrAMDvIlgDwDf7aNvvwsJCSS8t5/7u/v5e4+PjOjo6+pLn6uvrk6TXEo1/EggElJGRoampqU/nPD09lSTl5OS8uxar5GR/f197e3uSXjbhKSsrUyAQkM/nkzFGS0tLkqRIJPImZLtcLo2OjmplZUXSS103AHw1gjUAfLPU1FRJUjQalSSNjY2pqqpKktTS0qK4uDgFAoF3983Pz8vj8bx+1bZaaWmpWltbFQwGNTs7G3NMJBJRf3+/nE6nmpubP50zKytLkrS9vf3m/NPTU8wv43NzczG3e8/Ly5P0V8nLzs6Oampq9Pz8/OE4APhKBGsA+GY/O2QEg0FFIhFNT0/LbrdLkvLz8zUyMqL19XW1t7crHA7r7u5Oi4uL6unp0eDgoNLT07/s2SYnJ9XR0SG32y2Px6P9/X09Pj4qFAopEAiouLhY0WhUq6urSkxM/HQ+t9utlJQU+f1++f1+3dzc6Pz8XA0NDTo7O4t5z8LCgiYmJnR1daVoNKrNzU35fD7Z7XY1Nja+jguFQmpqatLx8bEeHx91cnKitrY2SVJnZ6c1PwgAfOS7+vwBwP+R0+l87e/86/FRn+Sf/Zx/Pbxe7+v129tbU1dXZ9LS0kxycrKpqKgwFxcXb+ZYXl42JSUlJjk52djtdlNQUGBmZmY+XWdtbc2sra29Ox+rn/ZHNjY2TH19vcnKyjIJCQkmKSnJuFwuMzAwYK6vr9+M9Xq9H653eHhoqqqqjMPhMAkJCSY3N9f4fD5TW1v7bvzl5aUZHh42RUVFxuFwGJvNZrKzs43b7TYHBwevcz48PJipqSnz48cP43Q6jc1mM5mZmaa8vNwEg8F/9a4A8F/9YQx/lQYAAAB+F6UgAAAAgAUI1gAAAIAFCNYAAACABQjWAAAAgAUI1gAAAIAFCNYAAACABQjWAAAAgAUI1gAAAIAFCNYAAACABQjWAAAAgAUI1gAAAIAFCNYAAACABQjWAAAAgAUI1gAAAIAFCNYAAACABQjWAAAAgAUI1gAAAIAF/gTEdnJOIECrrgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 382,
       "width": 363
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "esharpStream.plot('pitchclass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But maybe this one could tell someone something:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "tags": [
     "nbval-ignore-output"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 382,
       "width": 587
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "esharpStream.plot('pianoroll')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perhaps not.  But iterators are not the main point -- what you can do with them is more important, so we will return to working with actual musical objects in :ref:`Chapter 27 <usersGuide_27_graceNotes>` when we talk about Grace Notes."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
